home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / serial / serialutil.py < prev    next >
Text File  |  2008-06-25  |  14KB  |  377 lines
  1. #! /usr/bin/python
  2. #Python Serial Port Extension for Win32, Linux, BSD, Jython
  3. #see __init__.py
  4. #
  5. #(C) 2001-2003 Chris Liechti <cliechti@gmx.net>
  6. # this is distributed under a free software license, see license.txt
  7.  
  8. PARITY_NONE, PARITY_EVEN, PARITY_ODD = 'N', 'E', 'O'
  9. STOPBITS_ONE, STOPBITS_TWO = (1, 2)
  10. FIVEBITS, SIXBITS, SEVENBITS, EIGHTBITS = (5,6,7,8)
  11.  
  12. PARITY_NAMES = {
  13.     PARITY_NONE: 'None',
  14.     PARITY_EVEN: 'Even',
  15.     PARITY_ODD:  'Odd',
  16. }
  17.  
  18. XON  = chr(17)
  19. XOFF = chr(19)
  20.  
  21. #Python < 2.2.3 compatibility
  22. try:
  23.     True
  24. except:
  25.     True = 1
  26.     False = not True
  27.  
  28. class SerialException(Exception):
  29.     """Base class for serial port related exceptions."""
  30.  
  31. portNotOpenError = SerialException('Port not open')
  32.  
  33. class SerialTimeoutException(SerialException):
  34.     """Write timeouts give an exception"""
  35.  
  36. writeTimeoutError = SerialTimeoutException("Write timeout")
  37.  
  38. class FileLike(object):
  39.     """An abstract file like class.
  40.     
  41.     This class implements readline and readlines based on read and
  42.     writelines based on write.
  43.     This class is used to provide the above functions for to Serial
  44.     port objects.
  45.     
  46.     Note that when the serial port was opened with _NO_ timeout that
  47.     readline blocks until it sees a newline (or the specified size is
  48.     reached) and that readlines would never return and therefore
  49.     refuses to work (it raises an exception in this case)!
  50.     """
  51.  
  52.     def read(self, size): raise NotImplementedError
  53.     def write(self, s): raise NotImplementedError
  54.  
  55.     def readline(self, size=None, eol='\n'):
  56.         """read a line which is terminated with end-of-line (eol) character
  57.         ('\n' by default) or until timeout"""
  58.         line = ''
  59.         while 1:
  60.             c = self.read(1)
  61.             if c:
  62.                 line += c   #not very efficient but lines are usually not that long
  63.                 if c == eol:
  64.                     break
  65.                 if size is not None and len(line) >= size:
  66.                     break
  67.             else:
  68.                 break
  69.         return line
  70.  
  71.     def readlines(self, sizehint=None, eol='\n'):
  72.         """read a list of lines, until timeout
  73.         sizehint is ignored"""
  74.         if self.timeout is None:
  75.             raise ValueError, "Serial port MUST have enabled timeout for this function!"
  76.         lines = []
  77.         while 1:
  78.             line = self.readline(eol=eol)
  79.             if line:
  80.                 lines.append(line)
  81.                 if line[-1] != eol:    #was the line received with a timeout?
  82.                     break
  83.             else:
  84.                 break
  85.         return lines
  86.  
  87.     def xreadlines(self, sizehint=None):
  88.         """just call readlines - here for compatibility"""
  89.         return self.readlines()
  90.  
  91.     def writelines(self, sequence):
  92.         for line in sequence:
  93.             self.write(line)
  94.  
  95.     def flush(self):
  96.         """flush of file like objects"""
  97.         pass
  98.  
  99.     # iterator for e.g. "for line in Serial(0): ..." usage
  100.     def next(self):
  101.         line = self.readline()
  102.         if not line: raise StopIteration
  103.         return line
  104.  
  105.     def __iter__(self):
  106.         return self
  107.  
  108.  
  109. class SerialBase(FileLike):
  110.     """Serial port base class. Provides __init__ function and properties to
  111.        get/set port settings."""
  112.     
  113.     #default values, may be overriden in subclasses that do not support all values
  114.     BAUDRATES = (50,75,110,134,150,200,300,600,1200,1800,2400,4800,9600,
  115.                  19200,38400,57600,115200,230400,460800,500000,576000,921600,
  116.                  1000000,1152000,1500000,2000000,2500000,3000000,3500000,4000000)
  117.     BYTESIZES = (FIVEBITS, SIXBITS, SEVENBITS, EIGHTBITS)
  118.     PARITIES  = (PARITY_NONE, PARITY_EVEN, PARITY_ODD)
  119.     STOPBITS  = (STOPBITS_ONE, STOPBITS_TWO)
  120.     
  121.     def __init__(self,
  122.                  port = None,           #number of device, numbering starts at
  123.                                         #zero. if everything fails, the user
  124.                                         #can specify a device string, note
  125.                                         #that this isn't portable anymore
  126.                                         #port will be opened if one is specified
  127.                  baudrate=9600,         #baudrate
  128.                  bytesize=EIGHTBITS,    #number of databits
  129.                  parity=PARITY_NONE,    #enable parity checking
  130.                  stopbits=STOPBITS_ONE, #number of stopbits
  131.                  timeout=None,          #set a timeout value, None to wait forever
  132.                  xonxoff=0,             #enable software flow control
  133.                  rtscts=0,              #enable RTS/CTS flow control
  134.                  writeTimeout=None,     #set a timeout for writes
  135.                  dsrdtr=None,           #None: use rtscts setting, dsrdtr override if true or false
  136.                  ):
  137.         """Initialize comm port object. If a port is given, then the port will be
  138.            opened immediately. Otherwise a Serial port object in closed state
  139.            is returned."""
  140.  
  141.         self._isOpen   = False
  142.         self._port     = None           #correct value is assigned below trough properties
  143.         self._baudrate = None           #correct value is assigned below trough properties
  144.         self._bytesize = None           #correct value is assigned below trough properties
  145.         self._parity   = None           #correct value is assigned below trough properties
  146.         self._stopbits = None           #correct value is assigned below trough properties
  147.         self._timeout  = None           #correct value is assigned below trough properties
  148.         self._writeTimeout = None       #correct value is assigned below trough properties
  149.         self._xonxoff  = None           #correct value is assigned below trough properties
  150.         self._rtscts   = None           #correct value is assigned below trough properties
  151.         self._dsrdtr   = None           #correct value is assigned below trough properties
  152.         
  153.         #assign values using get/set methods using the properties feature
  154.         self.port     = port
  155.         self.baudrate = baudrate
  156.         self.bytesize = bytesize
  157.         self.parity   = parity
  158.         self.stopbits = stopbits
  159.         self.timeout  = timeout
  160.         self.writeTimeout = writeTimeout
  161.         self.xonxoff  = xonxoff
  162.         self.rtscts   = rtscts
  163.         self.dsrdtr   = dsrdtr
  164.         
  165.         if port is not None:
  166.             self.open()
  167.  
  168.     def isOpen(self):
  169.         """Check if the port is opened."""
  170.         return self._isOpen
  171.  
  172.     #  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
  173.  
  174.     #TODO: these are not realy needed as the is the BAUDRATES etc attribute...
  175.     #maybe i remove them before the final release...
  176.     
  177.     def getSupportedBaudrates(self):
  178.         return [(str(b), b) for b in self.BAUDRATES]
  179.  
  180.     def getSupportedByteSizes(self):
  181.         return [(str(b), b) for b in self.BYTESIZES]
  182.     
  183.     def getSupportedStopbits(self):
  184.         return [(str(b), b) for b in self.STOPBITS]
  185.  
  186.     def getSupportedParities(self):
  187.         return [(PARITY_NAMES[b], b) for b in self.PARITIES]
  188.  
  189.     #  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
  190.  
  191.     def setPort(self, port):
  192.         """Change the port. The attribute portstr is set to a string that
  193.            contains the name of the port."""
  194.         
  195.         was_open = self._isOpen
  196.         if was_open: self.close()
  197.         if port is not None:
  198.             if type(port) in [type(''), type(u'')]:       #strings are taken directly
  199.                 self.portstr = port
  200.             else:
  201.                 self.portstr = self.makeDeviceName(port)
  202.         else:
  203.             self.portstr = None
  204.         self._port = port
  205.         if was_open: self.open()
  206.     
  207.     def getPort(self):
  208.         """Get the current port setting. The value that was passed on init or using
  209.            setPort() is passed back. See also the attribute portstr which contains
  210.            the name of the port as a string."""
  211.         return self._port
  212.  
  213.     port = property(getPort, setPort, doc="Port setting")
  214.  
  215.  
  216.     def setBaudrate(self, baudrate):
  217.         """Change baudrate. It raises a ValueError if the port is open and the
  218.         baudrate is not possible. If the port is closed, then tha value is
  219.         accepted and the exception is raised when the port is opened."""
  220.         #~ if baudrate not in self.BAUDRATES: raise ValueError("Not a valid baudrate: %r" % baudrate)
  221.         try:
  222.             self._baudrate = int(baudrate)
  223.         except TypeError:
  224.             raise ValueError("Not a valid baudrate: %r" % (baudrate,))
  225.         else:
  226.             if self._isOpen:  self._reconfigurePort()
  227.         
  228.     def getBaudrate(self):
  229.         """Get the current baudrate setting."""
  230.         return self._baudrate
  231.         
  232.     baudrate = property(getBaudrate, setBaudrate, doc="Baudrate setting")
  233.  
  234.  
  235.     def setByteSize(self, bytesize):
  236.         """Change byte size."""
  237.         if bytesize not in self.BYTESIZES: raise ValueError("Not a valid byte size: %r" % (bytesize,))
  238.         self._bytesize = bytesize
  239.         if self._isOpen: self._reconfigurePort()
  240.     
  241.     def getByteSize(self):
  242.         """Get the current byte size setting."""
  243.         return self._bytesize
  244.     
  245.     bytesize = property(getByteSize, setByteSize, doc="Byte size setting")
  246.  
  247.  
  248.     def setParity(self, parity):
  249.         """Change parity setting."""
  250.         if parity not in self.PARITIES: raise ValueError("Not a valid parity: %r" % (parity,))
  251.         self._parity = parity
  252.         if self._isOpen: self._reconfigurePort()
  253.     
  254.     def getParity(self):
  255.         """Get the current parity setting."""
  256.         return self._parity
  257.     
  258.     parity = property(getParity, setParity, doc="Parity setting")
  259.  
  260.  
  261.     def setStopbits(self, stopbits):
  262.         """Change stopbits size."""
  263.         if stopbits not in self.STOPBITS: raise ValueError("Not a valid stopbit size: %r" % (stopbits,))
  264.         self._stopbits = stopbits
  265.         if self._isOpen: self._reconfigurePort()
  266.     
  267.     def getStopbits(self):
  268.         """Get the current stopbits setting."""
  269.         return self._stopbits
  270.     
  271.     stopbits = property(getStopbits, setStopbits, doc="Stopbits setting")
  272.  
  273.  
  274.     def setTimeout(self, timeout):
  275.         """Change timeout setting."""
  276.         if timeout is not None:
  277.             if timeout < 0: raise ValueError("Not a valid timeout: %r" % (timeout,))
  278.             try:
  279.                 timeout + 1     #test if it's a number, will throw a TypeError if not...
  280.             except TypeError:
  281.                 raise ValueError("Not a valid timeout: %r" % (timeout,))
  282.         
  283.         self._timeout = timeout
  284.         if self._isOpen: self._reconfigurePort()
  285.     
  286.     def getTimeout(self):
  287.         """Get the current timeout setting."""
  288.         return self._timeout
  289.     
  290.     timeout = property(getTimeout, setTimeout, doc="Timeout setting for read()")
  291.  
  292.  
  293.     def setWriteTimeout(self, timeout):
  294.         """Change timeout setting."""
  295.         if timeout is not None:
  296.             if timeout < 0: raise ValueError("Not a valid timeout: %r" % (timeout,))
  297.             try:
  298.                 timeout + 1     #test if it's a number, will throw a TypeError if not...
  299.             except TypeError:
  300.                 raise ValueError("Not a valid timeout: %r" % timeout)
  301.         
  302.         self._writeTimeout = timeout
  303.         if self._isOpen: self._reconfigurePort()
  304.     
  305.     def getWriteTimeout(self):
  306.         """Get the current timeout setting."""
  307.         return self._writeTimeout
  308.     
  309.     writeTimeout = property(getWriteTimeout, setWriteTimeout, doc="Timeout setting for write()")
  310.  
  311.  
  312.     def setXonXoff(self, xonxoff):
  313.         """Change XonXoff setting."""
  314.         self._xonxoff = xonxoff
  315.         if self._isOpen: self._reconfigurePort()
  316.     
  317.     def getXonXoff(self):
  318.         """Get the current XonXoff setting."""
  319.         return self._xonxoff
  320.     
  321.     xonxoff = property(getXonXoff, setXonXoff, doc="Xon/Xoff setting")
  322.  
  323.     def setRtsCts(self, rtscts):
  324.         """Change RtsCts flow control setting."""
  325.         self._rtscts = rtscts
  326.         if self._isOpen: self._reconfigurePort()
  327.     
  328.     def getRtsCts(self):
  329.         """Get the current RtsCts flow control setting."""
  330.         return self._rtscts
  331.     
  332.     rtscts = property(getRtsCts, setRtsCts, doc="RTS/CTS flow control setting")
  333.  
  334.     def setDsrDtr(self, dsrdtr=None):
  335.         """Change DsrDtr flow control setting."""
  336.         if dsrdtr is None:
  337.             #if not set, keep backwards compatibility and follow rtscts setting
  338.             self._dsrdtr = self._rtscts
  339.         else:
  340.             #if defined independently, follow its value
  341.             self._dsrdtr = dsrdtr
  342.         if self._isOpen: self._reconfigurePort()
  343.     
  344.     def getDsrDtr(self):
  345.         """Get the current DsrDtr flow control setting."""
  346.         return self._dsrdtr
  347.     
  348.     dsrdtr = property(getDsrDtr, setDsrDtr, "DSR/DTR flow control setting")
  349.     
  350.     #  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
  351.  
  352.     def __repr__(self):
  353.         """String representation of the current port settings and its state."""
  354.         return "%s<id=0x%x, open=%s>(port=%r, baudrate=%r, bytesize=%r, parity=%r, stopbits=%r, timeout=%r, xonxoff=%r, rtscts=%r, dsrdtr=%r)" % (
  355.             self.__class__.__name__,
  356.             id(self),
  357.             self._isOpen,
  358.             self.portstr,
  359.             self.baudrate,
  360.             self.bytesize,
  361.             self.parity,
  362.             self.stopbits,
  363.             self.timeout,
  364.             self.xonxoff,
  365.             self.rtscts,
  366.             self.dsrdtr,
  367.         )
  368.  
  369. if __name__ == '__main__':
  370.     s = SerialBase()
  371.     print s.portstr
  372.     print s.getSupportedBaudrates()
  373.     print s.getSupportedByteSizes()
  374.     print s.getSupportedParities()
  375.     print s.getSupportedStopbits()
  376.     print s
  377.